home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2007 December / PCWKCD1207B.iso / Blogowanie poza sfera / Flock 1.0 beta / flock-1.0RC3.en-US.win32.exe / flock / components / flockYoutubeService.js < prev    next >
Text File  |  2007-10-18  |  69KB  |  1,990 lines
  1. // vim: ts=2 sw=2 expandtab cindent
  2. //
  3. // BEGIN FLOCK GPL
  4. // 
  5. // Copyright Flock Inc. 2005-2007
  6. // http://flock.com
  7. // 
  8. // This file may be used under the terms of of the
  9. // GNU General Public License Version 2 or later (the "GPL"),
  10. // http://www.gnu.org/licenses/gpl.html
  11. // 
  12. // Software distributed under the License is distributed on an "AS IS" basis,
  13. // WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  14. // for the specific language governing rights and limitations under the
  15. // License.
  16. // 
  17. // END FLOCK GPL
  18.  
  19. // Developer ID = 1aiV9CsTs3o
  20. // Developer Secret = flock_is_open_source
  21.  
  22. const ENABLE_DEBUG = true; // switch to turn off slow debug code for production
  23. function DEBUG(x) { if (ENABLE_DEBUG) debug("flockYouTubeService: "+x+"\n"); }
  24.  
  25. const Cc = Components.classes;
  26. const Ci = Components.interfaces;
  27. const Cr = Components.results;
  28.  
  29. Components.utils.import("resource://gre/modules/JSON.jsm");
  30. Components.utils.import("resource:///modules/FlockScheduler.jsm");
  31.  
  32. const YT_DEVID = "1aiV9CsTs3o";
  33. const YT_DEVSECRET = "flock_is_open_source";
  34. const YOUTUBE_CID = Components.ID('{DCB6A01E-7D4A-4C30-AB3D-9CC98C02F617}');
  35. const YOUTUBE_CONTRACTID = '@flock.com/?photo-api-youtube;1';
  36. const YOUTUBE_FAVICON = "http://www.youtube.com/favicon.ico";
  37. const YOUTUBE_TITLE = "YouTube Web Service";
  38. const SERVICE_ENABLED_PREF          = "flock.service.youtube.enabled";
  39. const CATEGORY_COMPONENT_NAME       = "YouTube JS Component"
  40. const CATEGORY_ENTRY_NAME           = "youtube"
  41. const FRIENDS_AVATAR_TIMEOUT = 5000;  // in milliseconds
  42. const FRIENDS_ACTIVITY_TIMEOUT = 500;  // in milliseconds
  43.  
  44. const FLOCK_PHOTOPERSON_CONTRACTID  = '@flock.com/photo-person;1';
  45.  
  46. const PROPERTY_BAG_CONTRACTID = "@mozilla.org/hash-property-bag;1";
  47. const XHR_CONTRACTID = "@mozilla.org/xmlextras/xmlhttprequest;1";
  48. const FLOCK_RDDS_CONTRACTID = "@flock.com/rich-dnd-service;1";
  49.  
  50. const OBS_TOPIC_XPCOMSHUTDOWN = "xpcom-shutdown";
  51. const YOUTUBE_IDENTITY_URN_PREFIX = "urn:flock:identity:youtube:";
  52. const PEOPLE_PROPERTIES = "chrome://flock/locale/people/people.properties";
  53. const YOUTUBE_STRING_BUNDLE = "chrome://flock/locale/services/youtube.properties";
  54.  
  55. // From nsIXMLHttpRequest.idl
  56. // 4: COMPLETED     Finished with all operations.
  57. const XMLHTTPREQUEST_READYSTATE_COMPLETED = 4;
  58.  
  59. const HTTP_CODE_OK = 200;
  60.  
  61. // The delay between two refreshes when the sidebar is closed (in seconds)
  62. const YOUTUBE_REFRESH_INTERVAL = 3600; // 60 minutes
  63. // The delay between two refreshes when the sidebar is open (in seconds)
  64. const YOUTUBE_SHORT_INTERVAL = 3600; // 60 minutes
  65.  
  66.  
  67. var gCompTK;
  68. function getCompTK() {
  69.   if (!gCompTK) {
  70.     gCompTK = Cc["@flock.com/singleton;1"]
  71.                 .getService(Ci.flockISingleton)
  72.                 .getSingleton("chrome://browser/content/flock/services/common/load-compTK.js")
  73.                 .wrappedJSObject;
  74.   }
  75.   return gCompTK;
  76. }
  77.  
  78. function _getIdentityUrn(aAccountId, aUid) {
  79.   var result = YOUTUBE_IDENTITY_URN_PREFIX
  80.              + aAccountId + ":"
  81.              + aUid;
  82.   return result;
  83. }
  84.  
  85. loadLibraryFromSpec("chrome://browser/content/flock/photo/photoAPI.js");
  86.  
  87. var gTimers = [];  // For use with the scheduler
  88.  
  89. // String defaults... may be updated later through Web Detective
  90. var gStrings = {
  91.   "domains": "youtube.com",
  92.   "userlogin": "http://www.youtube.com/login",
  93.   "userprofile": "http://www.youtube.com/profile?user=%accountid%",
  94.   "editprofile": "http://youtube.com/my_profile",
  95.   "inbox": "http://youtube.com/my_messages",
  96.   "noavatarimage": "no_videos_140.jpg"
  97. };
  98.  
  99. function youtubeVideo() {
  100. }
  101.  
  102. youtubeVideo.prototype= {
  103.   id: "",
  104.   thumbnail: "",
  105.   webPageUrl: "",
  106.   midSizePhoto: "",
  107.   largeSizePhoto: "",
  108.   title: "",
  109.   username: "",
  110.   userid: "",
  111.   is_public: "true",
  112.   is_video: "true",
  113.   has_miniView: "true",
  114.   svcShortName: 'youtube',
  115.   buildTooltip: function( ) {
  116.     // do we have to use document from the window to ceate elements? -- ja
  117.     var wm = Cc["@mozilla.org/appshell/window-mediator;1"]
  118.                 .getService(Ci.nsIWindowMediator);
  119.     var win = wm.getMostRecentWindow('navigator:browser');
  120.     if (!win) return null;
  121.  
  122.     var box = win.document.createElement('vbox');
  123.     box.setAttribute('style', 'max-width: 250px');
  124.  
  125.     var title = win.document.createElement('label');
  126.     title.setAttribute('value', this.title );
  127.     title.setAttribute('crop', 'end');
  128.     box.appendChild(title);
  129.  
  130.     if( this.length_seconds)
  131.     {
  132.       var lbl = win.document.createElement('label');
  133.       lbl.setAttribute('value', 'Length: ' + this.length_seconds + ' seconds');
  134.       box.appendChild(lbl);
  135.     }
  136.     if(this.rating_avg)
  137.     {
  138.       var lbl = win.document.createElement('label');
  139.       lbl.setAttribute('value', 'Rating: ' + this.rating_avg + ' (' + this.rating_count + ' times)');
  140.       box.appendChild(lbl);
  141.     }
  142.     if(this.view_count)
  143.     {
  144.       var lbl = win.document.createElement('label');
  145.       lbl.setAttribute('value', 'Views: ' + this.view_count );
  146.       box.appendChild(lbl);
  147.     }
  148.  
  149.     if(!(this.length_seconds && this.rating_avg && this.view_count))
  150.     {
  151.       //if the tooltip does not these metadata -- show the author
  152.       var lbl = win.document.createElement('label');
  153.       lbl.setAttribute('value', this.username );
  154.       lbl.setAttribute('class', 'user');
  155.       box.appendChild(lbl);
  156.     }
  157.  
  158.     var vbox = win.document.createElement('vbox');
  159.     var cbox = win.document.createElement('cbox');
  160.     var largeImg = win.document.createElement('image');
  161.     largeImg.setAttribute('src', this.midSizePhoto);
  162.     largeImg.setAttribute('style', 'margin-bottom: 2px;');
  163.     var spacer = win.document.createElement('spacer');
  164.     spacer.setAttribute('flex', '1');
  165.     cbox.appendChild(largeImg);
  166.     cbox.appendChild(spacer);
  167.     vbox.appendChild(cbox);
  168.     vbox.appendChild(box);
  169.  
  170.     return vbox;
  171.   },
  172.   buildHTML: function ( ) {
  173.     var flashUrl = this.webPageUrl.replace(/\/\?v\=/,'/v/');
  174.  
  175.     return '<object width="425" height="350">'
  176.          + '<param name="movie" value="'+flashUrl+'"/>'
  177.          + '<embed src="'+flashUrl+'" type="application/x-shockwave-flash" width="425" height="350"/>'
  178.          + this.webPageUrl
  179.          + '</object>';
  180.   },
  181.   buildBBCode: function ( ) {
  182.     var video = this.webPageUrl.replace(/\/\?v\=/,'/watch?v=');
  183.     return '[youtube]' + video + '[/youtube]'
  184.   },
  185.   buildMiniPage: function ( ) {
  186.     var theurl = this.webPageUrl.replace(/\/\?v\=/,'/v/');
  187.     return '<html><head><title>' + this.title + ' (' + this.username + ')</title></head>' +
  188.            '<body><object width="425" height="350">' +
  189.            '<param name="movie" value="'+theurl+'"/>' +
  190.            '<center><embed src="'+theurl+'&autoplay=1" type="application/x-shockwave-flash" width="425" height="350"/></object></center></body></html>';
  191.   },
  192.  
  193.   QueryInterface: function(iid) {
  194.     if (!iid.equals(Ci.nsISupports) &&
  195.         !iid.equals(Ci.flockIPhoto)) {
  196.       throw Components.results.NS_ERROR_NO_INTERFACE;
  197.     }
  198.     return this;
  199.   }
  200. };
  201.  
  202. youtubeVideo.prototype.__defineGetter__('metaData', function () {
  203.   var metaData = Cc["@mozilla.org/hash-property-bag;1"].createInstance(Ci.nsIWritablePropertyBag2);
  204.   metaData.setPropertyAsAString("title", this.title);
  205.   metaData.setPropertyAsAString("length", this.length_seconds);
  206.   metaData.setPropertyAsAString("views", this.view_count);
  207.   metaData.setPropertyAsAString("rating", this.rating_avg);
  208.  
  209.   metaData.QueryInterface(Ci.nsIPropertyBag);
  210.  
  211.   return metaData;
  212. })
  213.  
  214.  
  215. // ================================================
  216. // ========== BEGIN youtubeService class ==========
  217. // ================================================
  218.  
  219. function youtubeService()
  220. {
  221.   this.obs = Components.classes["@mozilla.org/observer-service;1"]
  222.                        .getService(Components.interfaces.nsIObserverService);
  223.   this.obs.addObserver(this, OBS_TOPIC_XPCOMSHUTDOWN, false);
  224.   this.acUtils = Components.classes["@flock.com/account-utils;1"]
  225.                            .getService(Components.interfaces.flockIAccountUtils);
  226.   this.status = Components.interfaces.flockIWebService.STATUS_UNKNOWN;
  227.   this.url = "http://www.youtube.com";
  228.   this.mIsInitialized = false;
  229.   this._ctk = {
  230.     interfaces: [
  231.       "nsISupports",
  232.       "nsISupportsCString",
  233.       "nsIClassInfo",
  234.       "nsIObserver",
  235.       "flockIWebService",
  236.       "flockIMediaWebService",
  237.       "flockISocialWebService",
  238.       "flockIYoutubeService",
  239.       "flockIManageableWebService",
  240.       "flockIPollingService",
  241.       "flockIRichContentDropHandler"
  242.     ],
  243.     shortName: "youtube",
  244.     fullName: "YouTube",
  245.     description: YOUTUBE_TITLE,
  246.     favicon: YOUTUBE_FAVICON,
  247.     CID: YOUTUBE_CID,
  248.     contractID: YOUTUBE_CONTRACTID,
  249.     accountClass: youtubeAccount,
  250.     needPassword: false
  251.   };
  252.  
  253.   var sbs = Cc["@mozilla.org/intl/stringbundle;1"]
  254.             .getService(Ci.nsIStringBundleService);
  255.   var bundle = sbs.createBundle(YOUTUBE_STRING_BUNDLE);
  256.  
  257.   this._channels = {
  258.     "special:added": {
  259.       title: bundle.GetStringFromName("flock.youtube.title.added"),
  260.       supportsSearch: false,
  261.       feed: "http://youtube.com/rss/global/recently_added.rss"
  262.     },
  263.     "special:featured": {
  264.       title: bundle.GetStringFromName("flock.youtube.title.featured"),
  265.       supportsSearch: false
  266.     },
  267.     "special:top_favorites": {
  268.       title: bundle.GetStringFromName("flock.youtube.title.topfav"),
  269.       supportsSearch: false,
  270.       feed: "http://youtube.com/rss/global/top_favorites.rss"
  271.     },
  272.     "special:rated": {
  273.       title: bundle.GetStringFromName("flock.youtube.title.rated"),
  274.       supportsSearch: false,
  275.       feed: "http://youtube.com/rss/global/top_rated.rss"
  276.     }
  277.   };
  278.  
  279.   this._logger = Cc['@flock.com/logger;1'].createInstance(Ci.flockILogger);
  280.   this._logger.init('youtube');
  281.   this._profiler = Cc["@flock.com/profiler;1"].getService(Ci.flockIProfiler);
  282.   this.init();
  283. }
  284.  
  285.  
  286. // BEGIN nsIObserver interface
  287. youtubeService.prototype.observe =
  288. function youtubeService_observe(subject, topic, state)
  289. {
  290.   switch (topic) {
  291.     case OBS_TOPIC_XPCOMSHUTDOWN:
  292.     {
  293.       this.obs.removeObserver(this, OBS_TOPIC_XPCOMSHUTDOWN);
  294.     }; break;
  295.   }
  296. }
  297. // END nsIObserver interface
  298.  
  299.  
  300. youtubeService.prototype.init =
  301. function youtubeService_init()
  302. {
  303.   DEBUG(".init()");
  304.  
  305.   // Prevent re-entry
  306.   if (this.mIsInitialized) return;
  307.   this.mIsInitialized = true;
  308.  
  309.   var evtID = this._profiler.profileEventStart("youtube-init");
  310.  
  311.   this.prefService = Components.classes["@mozilla.org/preferences-service;1"]
  312.                                .getService(Components.interfaces.nsIPrefBranch);
  313.   if ( this.prefService.getPrefType(SERVICE_ENABLED_PREF) &&
  314.        !this.prefService.getBoolPref(SERVICE_ENABLED_PREF) )
  315.   {
  316.     DEBUG("Pref "+SERVICE_ENABLED_PREF+" set to FALSE... not initializing.");
  317.     var catMgr = Cc["@mozilla.org/categorymanager;1"].getService(Ci.nsICategoryManager);
  318.     catMgr.deleteCategoryEntry("wsm-startup", CATEGORY_COMPONENT_NAME, true);
  319.     catMgr.deleteCategoryEntry("flockWebService", CATEGORY_ENTRY_NAME, true);
  320.     catMgr.deleteCategoryEntry("flockMediaProvider", CATEGORY_ENTRY_NAME, true);
  321.     return;
  322.   }
  323.  
  324.   this.faves_coop = Components.classes['@flock.com/singleton;1']
  325.                               .getService(Components.interfaces.flockISingleton)
  326.                               .getSingleton("chrome://flock/content/common/load-faves-coop.js")
  327.                               .wrappedJSObject;
  328.   this.account_root = this.faves_coop.accounts_root;
  329.  
  330.   this.ytService = new this.faves_coop.Service(
  331.     "urn:youtube:service",
  332.     {
  333.       name: "youtube",
  334.       desc: "The YouTube Service",
  335.       loginURL: gStrings["userlogin"],
  336.       contactLabel: 'Contacts'
  337.     }
  338.   );
  339.   this.ytService.serviceId = YOUTUBE_CONTRACTID;
  340.  
  341.   // Load Web Detective file
  342.   this.webDetective = this.acUtils.useWebDetective("youtube.xml");
  343.   for (var s in gStrings) {
  344.     gStrings[s] = this.webDetective.getString("youtube", s, gStrings[s]);
  345.   }
  346.   this.ytService.domains = gStrings["domains"];
  347.  
  348.   this.urn = this.ytService.id();
  349.  
  350.   this._updateFriendAvatarsComplete = false;
  351.   
  352.   this._updateFriendActivityComplete = false;
  353.   this._friendActivityArray = [];
  354.   
  355.   this._profiler.profileEventEnd(evtID, "");
  356. }
  357.  
  358. youtubeService.prototype.getError =
  359. function youtubeService_getError (aErrorType, aXML, aHTTPErrorCode) {
  360.   var error = Components.classes["@flock.com/error;1"].createInstance(Ci.flockIError);
  361.   if  (aErrorType == "HTTP_ERROR") {
  362.     error.errorCode = aHTTPErrorCode;
  363.   } else if (aErrorType == "SERVICE_ERROR") {
  364.     var errorCode;
  365.     var errorMessage;
  366.     var serviceErrorMessage;
  367.     try {
  368.       errorCode = aXML.getElementsByTagName("error")[0].getAttribute('code');
  369.       serviceErrorMessage = aXML.getElementsByTagName("error")[0].getAttribute('description');
  370.     } catch (ex) {
  371.       errorCode = "999" // in case the error xml is invalid
  372.     }
  373.  
  374.     switch (errorCode) { // http://www.youtube.com/dev_error_codes
  375.       case "1":
  376.         error.errorCode = error.HTTP_INTERNAL_SERVER_ERROR;
  377.       break;
  378.  
  379.       case "2": // These errors are due to Flock sending a bad request
  380.       case "3":
  381.       case "4":
  382.       case "5":
  383.       case "6":
  384.         error.errorCode = error.PHOTOSERVICE_INVALID_QUERY;
  385.       break;
  386.  
  387.       case "7":
  388.       case "8":
  389.         error.errorCode = error.PHOTOSERVICE_INVALID_API_KEY;
  390.         break;
  391.  
  392.       case "999":
  393.         error.errorCode = error.PHOTOSERVICE_UNKNOWN_ERROR;
  394.       break;
  395.  
  396.       default:
  397.         error.errorCode = error.PHOTOSERVICE_UNKNOWN_ERROR;
  398.       break;
  399.     }
  400.   }
  401.   error.serviceErrorCode = errorCode;
  402.   error.serviceErrorString = serviceErrorMessage;
  403.   this._logger.error(error.errorString);
  404.   return error;
  405. };
  406.  
  407. youtubeService.prototype.supportsSearch =
  408. function youtubeService_supportsSearch( aQueryString ) {
  409.   var aQuery = new queryHelper(aQueryString);
  410.  
  411.   if (aQuery.special) {
  412.     var channel = this._channels["special:" + aQuery.special];
  413.     if (channel) {
  414.       return channel.supportsSearch;
  415.     }
  416.   }
  417.  
  418.   // none of the other apis/feeds support search
  419.   return false;
  420. }
  421.  
  422. youtubeService.prototype.call =
  423. function youtubeService_call(aListener, aMethod, aParams)
  424. {
  425.   var url = "http://www.youtube.com/api2_rest?method=" + aMethod + "&dev_id=" + YT_DEVID;
  426.   for (p in aParams) {
  427.     url += "&" + p + "=" + aParams[p];
  428.   }
  429.   var hr = Components.classes['@mozilla.org/xmlextras/xmlhttprequest;1']
  430.                      .createInstance(Components.interfaces.nsIXMLHttpRequest)
  431.                      .QueryInterface(Components.interfaces.nsIJSXMLHttpRequest);
  432.  
  433.   var inst = this;
  434.   hr.onreadystatechange = function (aEvt) {
  435.     if (hr.readyState == 4) {
  436.       try {
  437.         if (hr.status/100 == 2) {
  438.           var rsp = hr.responseXML.getElementsByTagName("ut_response")[0];
  439.           var stat = rsp.getAttribute("status");
  440.           if (stat != "ok") {
  441.             var error = inst.getError('SERVICE_ERROR', hr.responseXML, null);
  442.             aListener.onError(error);
  443.           }
  444.           else {
  445.             aListener.onResult(hr.responseXML);
  446.           }
  447.         }
  448.         else {
  449.           // http errors
  450.           aListener.onError(inst.getError("HTTP_ERROR", null, hr.status));
  451.         }
  452.       } catch(e) {
  453.         // XMHTTPERROR (connection lost)
  454.         inst._logger.error(e);
  455.         aListener.onError(inst.getError("HTTP_ERROR", null, "9001"));
  456.       }
  457.     }
  458.   };
  459.  
  460.   hr.backgroundRequest = true;
  461.   hr.open('GET',  url,true);
  462.   hr.send(null);
  463. }
  464.  
  465. youtubeService.prototype.getFeed =
  466. function youtubeService_getFeed(aListener, aFeedURL)
  467. {
  468.   ios = Components.classes["@mozilla.org/network/io-service;1"]
  469.     .getService(Components.interfaces.nsIIOService);
  470.   var uri = ios.newURI(aFeedURL, null, null);
  471.  
  472.   var ytServ = this;
  473.   var feedListener = {
  474.     onGetFeedComplete: function oncomplete (feed) {
  475.       ytServ.handleFeedResult(aListener, feed);
  476.     },
  477.     onError: aListener.onError
  478.   };
  479.  
  480.   var fm = Components.classes["@flock.com/feed-manager;1"]
  481.     .getService(Components.interfaces.flockIFeedManager);
  482.   fm.getFeedBypassCache(uri, feedListener);
  483. }
  484.  
  485. youtubeService.prototype.createAlbum =
  486. function youtubeService_createAlbum(aListener, aAlbumName)
  487. {
  488.   throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
  489. }
  490.  
  491. youtubeService.prototype.findByUsername =
  492. function youtubeService_findByUsername(aListener, aUsername)
  493. {
  494.   var inst = this;
  495.   var myListener = {
  496.     onResult: function (aXML) {
  497.       var newUserObj = Components.classes[FLOCK_PHOTOPERSON_CONTRACTID]
  498.                                  .createInstance(Components.interfaces.flockIPhotoPerson);
  499.       newUserObj.service = inst;
  500.       newUserObj.id = aUsername;
  501.       newUserObj.username = aUsername;
  502.       newUserObj.fullname = aUsername;
  503.       aListener.onFindByUsernameResult(newUserObj);
  504.     },
  505.     onError: function (aXML) {
  506.       aListener.onError(aXML);
  507.     }
  508.   }
  509.   var params = {};
  510.   params.user = aUsername;
  511.   this.call(myListener, "youtube.users.get_profile", params);
  512. }
  513.  
  514. youtubeService.prototype.getAlbums = function(aListener, aUsername) { throw Components.results.NS_ERROR_NOT_IMPLEMENTED; }
  515. youtubeService.prototype.getAuthPerson = function() {
  516.   if (!this.user) return null;
  517.   var newUserObj = Components.classes[FLOCK_PHOTOPERSON_CONTRACTID]
  518.                              .createInstance(Components.interfaces.flockIPhotoPerson);
  519.   newUserObj.id = this.api.user.username
  520.   newUserObj.username = this.api.user.username;
  521.   newUserObj.fullname = this.api.user.username;
  522.   newUserObj.service = this;
  523.   return newUserObj;
  524. }
  525. youtubeService.prototype.getContacts = function(aListener) { throw Components.results.NS_ERROR_NOT_IMPLEMENTED; }
  526. youtubeService.prototype.getMostRecentPhotoForList = function(aListener, aEnumerator) { throw Components.results.NS_ERROR_NOT_IMPLEMENTED; }
  527. youtubeService.prototype.getPhoto = function(aListener, aPhotoID) { throw Components.results.NS_ERROR_NOT_IMPLEMENTED; }
  528. youtubeService.prototype.login = function(aAccountURN, aListener) { throw Components.results.NS_ERROR_NOT_IMPLEMENTED; }
  529.  
  530. youtubeService.prototype.queryChannel =
  531. function youtubeService_queryChannel(aListener, aQueryString, aCount, aPage)
  532. {
  533.   var aQuery = new queryHelper(aQueryString);
  534.   // return; // XXX TODO FIXME: This is killing perf
  535.  
  536.   var inst = this;
  537.   var myListener = {
  538.     onResult: function (aXML) {
  539.       var rval = inst.handlePhotosResult(aXML);
  540.       var enum_ = {
  541.         hasMoreElements: function() {
  542.           return (rval.length > 0);
  543.         },
  544.         getNext: function() {
  545.           return rval.shift();
  546.         }
  547.       }
  548.       aListener.onSearchResult(enum_);
  549.     },
  550.     onError: function (aError) {
  551.       aListener.onError(aError);
  552.     }
  553.   }
  554.  
  555.   var params = {}
  556.   if (aQuery.search) {
  557.     params.tag = aQuery.search;
  558.     params.page = aPage;
  559.     params.per_page = aCount;
  560.     this.call(myListener, 'youtube.videos.list_by_tag', params);
  561.   } else {
  562.     // this API call doesn't support pagination and only shows most recent 25 items
  563.     if (aPage > 1) return;
  564.  
  565.     var channel = this._channels[aQuery.stringVal];
  566.     if (!channel) return;
  567.  
  568.     if (channel.feed)
  569.       this.getFeed(aListener, channel.feed);
  570.     else
  571.       this.call(myListener, "youtube.videos.list_featured", params);
  572.   }
  573. }
  574.  
  575. youtubeService.prototype.search =
  576. function youtubeService_search( aListener, aQueryString, aCount, aPage )
  577. {
  578.   var aQuery = new queryHelper(aQueryString);
  579.   if (aPage > 1) return; // youtube doesn't support pagination
  580.   if(aQuery.favorites && !aQuery.user)
  581.   {
  582.     aQuery.user = aQuery.favorites;
  583.   }
  584.   if (!aQuery.user && aQuery.special != "favorites") {
  585.        this.queryChannel( aListener, aQueryString, aCount, aPage );
  586.        return;
  587.   }
  588.  
  589.   var aUserid = aQuery.user;
  590.  
  591.   var params = {
  592.     user: aUserid
  593.   };
  594.  
  595.   var inst = this;
  596.   var myListener = {
  597.     onResult: function (aXML) {
  598.       var rval = inst.handlePhotosResult(aXML, aUserid);
  599.       var enum_ = {
  600.         hasMoreElements: function() {
  601.           return (rval.length > 0);
  602.         },
  603.         getNext: function() {
  604.           return rval.shift();
  605.         }
  606.       }
  607.       aListener.onSearchResult(enum_);
  608.     },
  609.     onError: function (aError) {
  610.       aListener.onError(aError);
  611.     }
  612.   }
  613.  
  614.   if (aQuery.favorites) {
  615.     this.call(myListener, "youtube.users.list_favorite_videos", params);
  616.   } else {
  617.     this.call(myListener, "youtube.videos.list_by_user", params);
  618.   }
  619. }
  620.  
  621. youtubeService.prototype.getPhotoFromRDFNode =
  622. function (aRDFId)
  623. {
  624.   var newPhoto = new youtubeVideo();
  625.   var coopPhoto = this.faves_coop.get(aRDFId);
  626.   newPhoto.webPageUrl = coopPhoto.URL;
  627.   newPhoto.thumbnail = coopPhoto.thumbnail;
  628.   newPhoto.midSizePhoto = coopPhoto.midSizePhoto;
  629.   newPhoto.largeSizePhoto = coopPhoto.largeSizePhoto;
  630.   newPhoto.username = coopPhoto.username;
  631.   newPhoto.userid = coopPhoto.userid;
  632.   newPhoto.title = coopPhoto.name;
  633.   newPhoto.id = coopPhoto.photoid;
  634.   newPhoto.icon = coopPhoto.favicon;
  635.   newPhoto.uploadDate = coopPhoto.datevalue;
  636.   newPhoto.is_public = coopPhoto.is_public;
  637.   newPhoto.is_video = "true";
  638.   return newPhoto;
  639.   // JMC XXX TODO: Gotta add the video-specific fields into the RDF, or somewhere
  640.   // eg content length, rating, etc.
  641.  
  642. }
  643.  
  644. youtubeService.prototype.handlePhotosResult =
  645. function youtubeService_handlePhotoResult(aXML, aUserid)
  646. {
  647.   var rval = [];
  648.   var photoList = aXML.getElementsByTagName("video");
  649.   for (var i = 0; i < photoList.length; i++) {
  650.     var photo = photoList[i];
  651.     var newPhoto = new youtubeVideo();
  652.     for (var j = 0; j < photo.childNodes.length; j++)
  653.     {
  654.       var child = photo.childNodes[j];
  655.       var contentNode = child.childNodes[0];
  656.       var childContent = "";
  657.       if (contentNode) childContent = contentNode.nodeValue;
  658.       switch (child.tagName)
  659.       {
  660.         case "author":
  661.           newPhoto.username   = childContent;
  662.           newPhoto.userid   = childContent;
  663.         break;
  664.         // case "id":     newPhoto.id     = childContent; break;
  665.         case "title":   newPhoto.title     = childContent; break;
  666.         case "upload_time":
  667.           newPhoto.uploadDate = childContent * 1000;
  668.           newPhoto.id = parseInt(childContent);
  669.         break;
  670.         case "length_seconds":
  671.           newPhoto.length_seconds = childContent;
  672.           break
  673.         case "rating_avg":
  674.           newPhoto.rating_avg = childContent;
  675.           break
  676.         case "description":
  677.           newPhoto.description = childContent;
  678.           break
  679.         case "comment_count":
  680.           newPhoto.comment_count = childContent;
  681.           break
  682.         case "view_count":
  683.           newPhoto.view_count = childContent;
  684.           break
  685.         case "rating_count":
  686.           newPhoto.rating_count = childContent;
  687.           break
  688.         case "url":
  689.           newPhoto.webPageUrl  = childContent;
  690.         break;
  691.         case "thumbnail_url":
  692.           newPhoto.thumbnail     = childContent;
  693.           newPhoto.midSizePhoto   = childContent;
  694.           newPhoto.largeSizePhoto = childContent;
  695.         break;
  696.         // case "id":     newPhoto.id = childContent;
  697.         // break;
  698.       }
  699.     }
  700.  
  701.     newPhoto.is_public = "true";
  702.     newPhoto.is_video = true;
  703.     rval.push(newPhoto);
  704.   }
  705.   return rval;
  706. }
  707.  
  708. youtubeService.prototype.handleFeedResult =
  709. function youtubeService_handleFeedResult(aListener, aFeed)
  710. {
  711.   var photos = [];
  712.  
  713.   var items = aFeed.getItems();
  714.   while (items && items.hasMoreElements()) {
  715.     var item = items.getNext();
  716.  
  717.     var newPhoto = new youtubeVideo();
  718.  
  719.     newPhoto.title = item.getTitle();
  720.     newPhoto.webPageUrl = item.getLink().spec;
  721.  
  722.     newPhoto.uploadDate = item.getPubDate();
  723.     newPhoto.id = newPhoto.uploadDate / 1000;
  724.  
  725.     var author = item.getAuthor();
  726.     newPhoto.username = author;
  727.     newPhoto.userid = author;
  728.  
  729.     var desc = item.getContent();
  730.     var re = /<img [^>]*src="([^"]*)"/i;
  731.     var thumbnail = desc.match(re)[1];
  732.     newPhoto.thumbnail = thumbnail;
  733.     newPhoto.midSizePhoto = thumbnail;
  734.     newPhoto.largeSizePhoto = thumbnail;
  735.  
  736.     newPhoto.is_public = "true";
  737.     newPhoto.is_video = true;
  738.  
  739.     photos.push(newPhoto);
  740.   }
  741.  
  742.   var enum_ = {
  743.     hasMoreElements: function() {
  744.       return (photos.length > 0);
  745.     },
  746.     getNext: function() {
  747.       return photos.shift();
  748.     }
  749.   }
  750.   aListener.onSearchResult(enum_);
  751. }
  752.  
  753.  
  754. youtubeService.prototype.supportsFeature = function(aFeature) {
  755.   var supports = {};
  756.   supports.tags = true;
  757.   supports.title = true;
  758.   supports.fileName = false;
  759.   supports.contacts = true;
  760.   supports.privacy = false;
  761.   supports.albumCreation = false;
  762.   return (supports[aFeature] == true);
  763. }
  764. youtubeService.prototype.upload = function(aListener, aFile, aParams, aUpload) {  throw Components.results.NS_ERROR_NOT_IMPLEMENTED; }
  765.  
  766.  
  767. youtubeService.prototype.refresh =
  768. function youtubeService_refresh(aURN, aListener)
  769. {
  770.   DEBUG("refresh with aURN of " + aURN);
  771.   var refreshItem = this.faves_coop.get(aURN);
  772.  
  773.   if (refreshItem.isInstanceOf(this.faves_coop.Account)) {
  774.     this._logger.debug("refreshing an Account");
  775.     if (refreshItem.isAuthenticated) {
  776.       this.refreshAccount(aURN, aListener);
  777.     } else {
  778.       // If the user is not logged in, return a success without
  779.       // refreshing anything
  780.       aListener.onResult();
  781.     }
  782.   } else {
  783.     throw Components.results.NS_ERROR_ABORT;
  784.   }
  785. }
  786.  
  787. youtubeService.prototype.refreshAccount =
  788. function youtubeService_refreshAccount(aURN, aListener)
  789. {
  790.   if (!aURN) return;
  791.   var inst = this;
  792.   var coopAcct = this.faves_coop.get(aURN);
  793.   var individualSuccess = {};
  794.   individualSuccess.numberOfAnswers  = 0;
  795.   individualSuccess.listener = aListener;
  796.   individualSuccess.coopAcct = coopAcct;
  797.   individualSuccess.refreshNumber = 3;
  798.   
  799.   // get friends
  800.   var getFriendsListener = {
  801.     onResult: function getFriendsListener_onResult(aXML) {
  802.       inst._handleFriendsResult(aXML, coopAcct, individualSuccess);
  803.     },
  804.     onError: function getFriendsListener_onError(aXML) {
  805.       inst._logger.error("Error on getFriendsListener");
  806.     }
  807.   }
  808.  
  809.   // get new message count
  810.   var hr = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"]
  811.            .createInstance(Ci.nsIXMLHttpRequest);
  812.   hr.onreadystatechange = function updateUserAccount_onreadystatechange(aEvent) {
  813.     if (hr.readyState == 4) {
  814.       var results = Cc["@mozilla.org/hash-property-bag;1"]
  815.                     .createInstance(Ci.nsIWritablePropertyBag2);
  816.       if (inst.webDetective.detectNoDOM("youtube", "accountinfo", "",
  817.                                         hr.responseText, results))
  818.       {
  819.         // Set the message count
  820.         var messages = 0;
  821.         var msgCount = results.getPropertyAsAString("messages");
  822.         if (msgCount && msgCount.length) {
  823.           messages = msgCount;
  824.         }
  825.         inst._logger.debug("coopAcct.accountMessages " + messages);
  826.         if (coopAcct.accountMessages < messages) {
  827.           inst._lightPeopleIcon();
  828.         }
  829.         coopAcct.accountMessages = messages;
  830.  
  831.         // Set the avatar for the mecard.
  832.         // If avatar returned as YT no avatar, then set coop avatar to
  833.         // null and let people sidebar code set the Flock no avatar img.
  834.         if (results.getPropertyAsAString("avatar")
  835.                    .match(gStrings["noavatarimage"])) {
  836.           coopAcct.avatar = null;
  837.           inst._logger.debug("no avatar for account, setting to null\n");
  838.         } else {
  839.           var avatar = results.getPropertyAsAString("avatar");
  840.           coopAcct.avatar = inst._fixRelativeAvatarUrl(avatar);
  841.           inst._logger.debug("coopAcct.accountAvatar " + coopAcct.avatar);
  842.         }
  843.       } else {
  844.         coopAcct.accountMessages = 0;
  845.       }
  846.       inst._onIndividualSuccess(individualSuccess);
  847.     }
  848.   }
  849.   hr.open("GET", gStrings["userprofile"].replace("%accountid%", coopAcct.id()));
  850.   hr.send(null);
  851.  
  852.   var params = {};
  853.   params.user = coopAcct.accountId;
  854.   this.call(getFriendsListener, "youtube.users.list_friends", params);
  855. }
  856.  
  857. youtubeService.prototype._onIndividualSuccess =
  858. function youtubeService__onIndividualSuccess(aObj) {
  859.   aObj.numberOfAnswers++;
  860.   if (aObj.numberOfAnswers >= aObj.refreshNumber) {
  861.     if (this.acUtils.isPeopleSidebarOpen()) {
  862.       aObj.coopAcct.nextRefresh = new Date(Date.now()
  863.                                            + YOUTUBE_SHORT_INTERVAL * 1000);
  864.     }
  865.     if (aObj.listener) {
  866.       aObj.listener.onResult();
  867.     }
  868.   }
  869. }
  870.  
  871. youtubeService.prototype.markAllMediaSeen =
  872. function youtubeService_markAllMediaSeen(aIdentityUrn) {
  873.   var identity = this.faves_coop.get(aIdentityUrn);
  874.   identity.unseenMedia = 0;
  875. } 
  876.  
  877. youtubeService.prototype._lightPeopleIcon =
  878. function youtubeService__lightPeopleIcon() {
  879.   this._logger.debug("._lightPeopleIcon()");
  880.   this.obs.notifyObservers(null, "new-people-notification", null);
  881. }
  882.  
  883. youtubeService.prototype._updateFriendAvatars =
  884. function youtubeService__updateFriendAvatars(aURN, aInvidualSuccessObj) {
  885.   this._logger.info("._updateFriendAvatars");
  886.  
  887.   if (this._updateFriendAvatarsComplete || !aURN) {
  888.     return;
  889.   }
  890.  
  891.   // Array of friends accounts (coop objects, not URNs) used to get avatars
  892.   var friendsList = [];
  893.  
  894.   // Retrieve the account's friends list and add friends currently without an
  895.   // avatar to a list to be updated at a later time
  896.   var friendsEnum = this.faves_coop.get(aURN).friendsList.children.enumerate();
  897.   while (friendsEnum.hasMoreElements()) {
  898.     var friend = friendsEnum.getNext();
  899.     if (friend.avatar == "") {
  900.       this._logger.debug("adding friend with missing avatar for updating: "
  901.                          + friend.accountId + "\n");
  902.       friendsList.push(friend);
  903.       // Increment number count that onIndividualSucess needs to count to
  904.       aInvidualSuccessObj.refreshNumber++;
  905.     }
  906.   }
  907.  
  908.   var inst = this;
  909.  
  910.   var friendsTimerCallback = {
  911.     notify: function friendNotify(aTimer) {
  912.       // Scrape the friend page for their avatar
  913.       if (friendsList.length > 0) {
  914.         var friend = friendsList.shift();
  915.         var page = gStrings["userprofile"]
  916.                    .replace("%accountid%", friend.accountId);
  917.         var xhr = Cc[XHR_CONTRACTID].createInstance(Ci.nsIXMLHttpRequest);
  918.         xhr.open("GET", page, true);
  919.  
  920.         xhr.onreadystatechange = function friend_OnReadyStateChange(aEvent) {
  921.           if (xhr.readyState == XMLHTTPREQUEST_READYSTATE_COMPLETED) {
  922.             if (xhr.status == HTTP_CODE_OK) {
  923.               var results = Cc[PROPERTY_BAG_CONTRACTID]
  924.                             .createInstance(Ci.nsIWritablePropertyBag2);
  925.               if (inst.webDetective.detectNoDOM("youtube", "page", "",
  926.                                                 xhr.responseText, results))
  927.               {
  928.                 // If avatar returned as YT no avatar, then set coop avatar to
  929.                 // null and let people sidebar code set the Flock no avatar img.
  930.                 if (results.getPropertyAsAString("avatar")
  931.                            .match(gStrings["noavatarimage"])) {
  932.                   friend.avatar = null;
  933.                   inst._logger.debug("no avatar for friend: " + friend.accountId + "\n");
  934.                 } else {
  935.                   friend.avatar = results.getPropertyAsAString("avatar");
  936.                   friend.avatar = inst._fixRelativeAvatarUrl(friend.avatar);
  937.                   inst._logger.debug("found friend's avatar: " + friend.accountId
  938.                                      + ", " + friend.avatar + "\n");
  939.                 }
  940.               }
  941.               inst._onIndividualSuccess(aInvidualSuccessObj);
  942.             }
  943.           }
  944.         }
  945.  
  946.         inst._logger.debug("requesting avatar for: " + page + "\n");
  947.         xhr.send(null);
  948.       }
  949.  
  950.       // Kill the timer if there's nothing left to update in the array
  951.       if (friendsList.length < 1) {
  952.         inst._logger.debug("no friends without avatars left to update, "
  953.                            + "kill the timer");
  954.         inst._friendsTimer.cancel();
  955.         inst._friendsTimer = null;
  956.       }
  957.     }
  958.   };
  959.  
  960.   // Start the timer to update the account's friends avatars
  961.   if (!this._friendsTimer && friendsList.length > 0) {
  962.     this._logger.debug("found friends without avatars to update, "
  963.                        + "start the timer");
  964.     this._friendsTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
  965.     this._friendsTimer.initWithCallback(friendsTimerCallback,
  966.                                         FRIENDS_AVATAR_TIMEOUT,
  967.                                         Ci.nsITimer.TYPE_REPEATING_SLACK);
  968.  
  969.     // Once we've started updating friends without avatars, we only want to
  970.     // check once per session so as not to incur a performance hit
  971.     this._updateFriendAvatarsComplete = true;
  972.   }
  973. }
  974.  
  975. youtubeService.prototype._updateFriendAvatar =
  976. function youtubeService__updateFriendAvatar(aDocument, aAccountID) {
  977.   if (aDocument && aAccountID) {
  978.     var results = Cc[PROPERTY_BAG_CONTRACTID]
  979.                   .createInstance(Ci.nsIWritablePropertyBag2);
  980.  
  981.     if (this.webDetective.detect("youtube", "page", aDocument, results)) {
  982.       var friendID = results.getPropertyAsAString("friend");
  983.  
  984.       // Only need to update the friend avatar if we're visiting the friend's page
  985.       if (aAccountID != friendID) {
  986.         var friendURN = _getIdentityUrn(aAccountID, friendID);
  987.         if (friendURN) {
  988.           var friend = this.faves_coop.get(friendURN);
  989.           var avatar = results.getPropertyAsAString("avatar");
  990.           avatar = this._fixRelativeAvatarUrl(avatar);
  991.  
  992.           // Only need to update the friend avatar if it's changed
  993.           if (friend && friend.avatar != avatar) {
  994.             friend.avatar = avatar;
  995.           }
  996.         }
  997.       }
  998.     }
  999.   }
  1000. }
  1001.  
  1002. /**
  1003.  * The avatar URL we scraped may be a relative URL. If so, prepend
  1004.  * "http://www.youtube.com/" to it.
  1005.  */
  1006. youtubeService.prototype._fixRelativeAvatarUrl = 
  1007. function youtubeService__fixRelativeAvatarUrl(aUrl) {
  1008.   var url = aUrl;
  1009.  
  1010.   if (url.indexOf("http") != 0) {
  1011.     url = "http://www.youtube.com";
  1012.     // Do we need to add a leading slash?
  1013.     if (aUrl.indexOf("/") != 0) {
  1014.       url += "/";
  1015.     }
  1016.     url += aUrl;
  1017.   }
  1018.  
  1019.   return url;
  1020. }
  1021.  
  1022. youtubeService.prototype._personUpdateRequired =
  1023. function youtubeService__personUpdateRequired(aCoopPerson, aPerson) {
  1024.   return (aCoopPerson.name != aPerson.accountId);
  1025. }
  1026.  
  1027. youtubeService.prototype.addCoopPerson =
  1028. function youtubeService_addCoopPerson(aPhotoPerson, aCoopAccount)
  1029. {
  1030.   var person = aPhotoPerson;
  1031.   var identityUrn = _getIdentityUrn(aCoopAccount.accountId,
  1032.                                     person.accountId);
  1033.   var updating = this.faves_coop.Identity.exists(identityUrn);
  1034.   var identity;
  1035.   if (updating) {
  1036.     identity = this.faves_coop.get(identityUrn);
  1037.     if (this._personUpdateRequired(aCoopAccount,person)) {
  1038.       // Update data of the identity coop obj here
  1039.       identity.name = person.accountId;
  1040.       this._incrementMedia(identity, person);
  1041.     }
  1042.   } else {
  1043.     identity = new this.faves_coop.Identity(
  1044.       identityUrn,
  1045.       {
  1046.         name: person.accountId,
  1047.         serviceId: YOUTUBE_CONTRACTID,
  1048.         accountId: person.accountId,
  1049.         avatar: "",
  1050.         statusMessage: "",
  1051.         lastUpdateType: "media",
  1052.         lastUploadedMedia: person.videoCount
  1053.       }
  1054.     );
  1055.     aCoopAccount.friendsList.children.add(identity);
  1056.     this._addIdentityToActivityArray(identity);
  1057.   }
  1058. }
  1059.  
  1060. youtubeService.prototype._addIdentityToActivityArray =
  1061. function youtubeService__addIdentityToActivityArray(aIdentity) {
  1062.   this._logger.info("._addIdentityToActivityArray('"+ aIdentity.name + "')");
  1063.   
  1064.    //only want to add to array when friendsActivity timer is ready
  1065.   if (!this._updateFriendActivityComplete) {
  1066.     this._friendActivityArray.push(aIdentity);
  1067.   }
  1068. }
  1069.  
  1070. youtubeService.prototype._incrementMedia =
  1071. function youtubeService__incrementMedia(identity, person) {
  1072.   this._logger.info("._incrementMedia('"+identity.id() + "," + person.accountId +"')");
  1073.   
  1074.   if (identity.lastUploadedMedia != person.videoCount) {
  1075.     identity.lastUploadedMedia = person.videoCount;
  1076.     identity.unseenMedia = 1;
  1077.     this._addIdentityToActivityArray(identity);
  1078.   }
  1079. }
  1080.  
  1081. youtubeService.prototype._updateFriendRecentActivity =
  1082. function youtubeService__updateFriendRecentActivity(aIndividualSuccess) {
  1083.   this._logger.info("._updateFriendRecentActivity");
  1084.   var success = aIndividualSuccess;
  1085.   if (this._updateFriendActivityComplete ||
  1086.      this._friendActivityArray.length == 0)
  1087.   {
  1088.     this._onIndividualSuccess(success);
  1089.     return;
  1090.   }
  1091.   // We are successful for refresh after each friend in _friendActivityArray
  1092.   // list is updated
  1093.   success.refreshNumber += (this._friendActivityArray.length -1);
  1094.   var inst = this;
  1095.  
  1096.   var friendsTimerCallback = {
  1097.     notify: function friendNotify(aTimer) {
  1098.       inst._updateFriendActivityComplete = true;
  1099.       while(inst._friendActivityArray.length != 0)
  1100.       {
  1101.         var identity = inst._friendActivityArray.pop();
  1102.         inst._updateLastUpdateDate(identity, success);
  1103.         inst._logger.info("updating recent activity for " + identity.name);
  1104.       }
  1105.       inst._logger.debug("no friends without avatars left to update, "
  1106.                           + "kill the timer");
  1107.       inst._friendsActivityTimer.cancel();
  1108.       inst._friendsActivityTimer = null;
  1109.       inst._updateFriendActivityComplete = false;
  1110.       inst._friendActivityArray = null;
  1111.       inst._friendActivityArray = [];
  1112.       inst._logger.info("done updating recent activity");
  1113.     }
  1114.   };
  1115.  
  1116.   // Start the timer to update the account's friends avatars
  1117.   if (!this._friendsActivityTimer) {
  1118.     this._logger.debug("found friends without avatars to update, "
  1119.                        + "start the timer");
  1120.     this._friendsActivityTimer = Cc["@mozilla.org/timer;1"]
  1121.                                    .createInstance(Ci.nsITimer);
  1122.     this._friendsActivityTimer.initWithCallback(friendsTimerCallback,
  1123.                                         FRIENDS_ACTIVITY_TIMEOUT,
  1124.                                         Ci.nsITimer.TYPE_REPEATING_SLACK);
  1125.     this._updateFriendActivityComplete = false;
  1126.   }
  1127. }
  1128.  
  1129. youtubeService.prototype._updateLastUpdateDate =
  1130. function youtubeService__updateLastUpdateDate(aIdentity, aInvidualSuccessObj)
  1131. {
  1132.   this._logger.info("._updateLastUpdateDate('"+ aIdentity.name + "')");
  1133.   
  1134.   var identity = aIdentity;
  1135.   var params = {
  1136.     user: identity.name,
  1137.     page: 1,
  1138.     per_page: 1,
  1139.   };
  1140.  
  1141.   var inst = this;
  1142.   var myListener = {
  1143.     onResult: function (aXML) {
  1144.       inst._logger.info("onResult");
  1145.       var video = inst.handlePhotosResult(aXML);
  1146.       if (video.length == 1) {
  1147.         video = video[0];
  1148.         //Youtube gives us UNIX time in seconds, change to miliseconds
  1149.         var time = video.uploadDate / 1000;
  1150.         identity.lastUpdate = time;
  1151.       }
  1152.       inst._onIndividualSuccess(aInvidualSuccessObj);
  1153.     },
  1154.     onError: function (aError) {
  1155.       if (!identity.lastUpdate) {
  1156.         identity.lastUpdate = inst._numberFromString(identity.name);
  1157.       }
  1158.     }
  1159.   };
  1160.  
  1161.   this.call(myListener, "youtube.videos.list_by_user", params);
  1162. }
  1163.  
  1164. youtubeService.prototype._handleFriendsResult =
  1165. function youtubeService__handleFriendsResult(aXML, aAccount,
  1166.                                              aInvidualSuccessObj)
  1167. {
  1168.   DEBUG("._handleFriendsResult(aXML, aAccount)");
  1169.   
  1170.   var friendList = aXML.getElementsByTagName("friend");
  1171.   var inst = this;
  1172.   var peopleHash = [];
  1173.   DEBUG(" - found "+friendList.length+" friends");
  1174.   for (var i = 0; i < friendList.length; i++) {
  1175.     var friend = friendList[i];
  1176.     var friendObj = {};
  1177.     for (var j = 0; j < friend.childNodes.length; j++)
  1178.     {
  1179.       var child = friend.childNodes[j];
  1180.       var contentNode = child.childNodes[0];
  1181.       var childContent = "";
  1182.       if (contentNode) childContent = contentNode.nodeValue;
  1183.       switch (child.tagName)
  1184.       {
  1185.         case "user":
  1186.           friendObj.accountId = childContent;
  1187.           friendObj.name = childContent;
  1188.           break;
  1189.         case "video_upload_count":
  1190.           friendObj.videoCount = childContent;
  1191.           break;
  1192.       }
  1193.     }
  1194.     peopleHash[friendObj.accountId] = friendObj;
  1195.     peopleHash[friendObj.accountId].media = {
  1196.       count: 1,
  1197.       latest: friendObj.videoCount
  1198.     };
  1199.   }
  1200.   function myWorker(aShouldYield) {
  1201.     // ADD or update existing people
  1202.     for (var uid in peopleHash) {
  1203.       inst.addCoopPerson(peopleHash[uid], aAccount);
  1204.       if (aShouldYield()) {
  1205.         yield;
  1206.       }
  1207.     }
  1208.     
  1209.     // REMOVE locally people removed on the server
  1210.     var localEnum = aAccount.friendsList.children.enumerate();
  1211.     while (localEnum.hasMoreElements()) {
  1212.       var identity = localEnum.getNext();
  1213.       if (!peopleHash[identity.accountId]) {
  1214.         inst._logger.info("Friend " + identity.accountId
  1215.                                     + " has been deleted on the server");
  1216.         aAccount.friendsList.children.remove(identity);
  1217.         identity.destroy();
  1218.       }
  1219.     }
  1220.     inst._onIndividualSuccess(aInvidualSuccessObj);
  1221.     inst._updateFriendRecentActivity(aInvidualSuccessObj);
  1222.     inst._updateFriendAvatars(aAccount.id(), aInvidualSuccessObj);
  1223.   } // end myWorker()
  1224.     
  1225.   FlockScheduler.schedule(null, 0.05, 10, myWorker);
  1226. }
  1227.  
  1228. var loader = Components.classes["@mozilla.org/moz/jssubscript-loader;1"]
  1229.                        .getService(Components.interfaces.mozIJSSubScriptLoader);
  1230. loader.loadSubScript("chrome://browser/content/utilityOverlay.js");
  1231.  
  1232. // BEGIN flockIWebService interface
  1233. youtubeService.prototype.addAccountById =
  1234. function youtubeService_addAccountById(aAccountID, aIsTransient, aListener)
  1235. {
  1236.   DEBUG("{flockIWebService}.addAccountById('"+aAccountID+"', "+aIsTransient+", aListener)");
  1237.  
  1238.   var accountURN = "urn:flock:youtube:"+aAccountID;
  1239.   var account = this.faves_coop.get(accountURN);
  1240.   if (!account) {
  1241.     account = new this.faves_coop.Account(
  1242.       accountURN,
  1243.       {
  1244.         name: aAccountID,
  1245.         serviceId: YOUTUBE_CONTRACTID,
  1246.         service: this.ytService,
  1247.         accountId: aAccountID,
  1248.         URL: gStrings["userprofile"].replace("%accountid%", aAccountID),
  1249.         isTransient: aIsTransient,
  1250.         refreshInterval: YOUTUBE_REFRESH_INTERVAL,
  1251.         favicon: YOUTUBE_FAVICON
  1252.       }
  1253.     );
  1254.     this.account_root.children.add(account);
  1255.   }
  1256.   if (!account.friendsList) {
  1257.     var friendsListUrn = accountURN + ":friends";
  1258.     var friendsList = new this.faves_coop.FriendsList(
  1259.       friendsListUrn,
  1260.       {
  1261.         account: account
  1262.       }
  1263.     );
  1264.     account.friendsList = friendsList;
  1265.   }
  1266.   this.USER = account.id();
  1267.  
  1268.   // Instanciate account component
  1269.   var acct = this.getAccount(account.id());
  1270.   if (aListener) aListener.onSuccess(acct, "addAccount");
  1271.   return acct;
  1272. }
  1273. // END flockIWebService interface
  1274.  
  1275.  
  1276. // BEGIN flockIManageableWebService interface
  1277. youtubeService.prototype.updateAccountStatusFromDocument =
  1278. function youtubeService_updateAccountStatusFromDocument(aDocument)
  1279. {
  1280.   this._logger.info("{flockIManageableWebService}.updateAccountStatusFromDocument()");
  1281.   if (this.webDetective.detect("youtube", "loggedout", aDocument, null))
  1282.   {
  1283.     this.acUtils.markAllAccountsAsLoggedOut(YOUTUBE_CONTRACTID);
  1284.   } else if (this.webDetective.detect("youtube", "loggedin", aDocument, null)) {
  1285.     var results = Components.classes["@mozilla.org/hash-property-bag;1"]
  1286.                             .createInstance(Components.interfaces.nsIWritablePropertyBag2);
  1287.     if (this.webDetective.detect("youtube", "accountinfo", aDocument, results)) {
  1288.       var accountID = results.getPropertyAsAString("accountid");
  1289.       if (accountID && accountID.length) {
  1290.         var accountURN = this.acUtils.getAccountURNById(this.urn, accountID);
  1291.         var acct = this.faves_coop.get(accountURN);
  1292.         if (!acct.isAuthenticated) {
  1293.           var inst = this; 
  1294.           var loginListener = {
  1295.             onSuccess: function loginListener_onSuccess() {
  1296.               inst._logger.debug(".updateAccountStatusFromDocument(): "
  1297.                                 + "loginListener: onSuccess()");
  1298.               acct.isAuthenticated = true;
  1299.               inst._updateFriendAvatarsComplete = false;
  1300.             },
  1301.             onError: function loginListener_onError(aError) {
  1302.               inst._logger.debug(".updateAccountStatusFromDocument(): "
  1303.                                 + "loginListener: onError()");
  1304.               inst._logger.debug(aError ? (aError.errorString) : "No details");
  1305.             }
  1306.           };
  1307.           this.getAccount(accountURN).login(loginListener);
  1308.         }
  1309.       }
  1310.     }
  1311.   }
  1312. }
  1313. // END flockIManageableWebService interface
  1314.  
  1315.  
  1316. // BEGIN flockISocialWebService interface
  1317. // END flockISocialWebService interface
  1318.  
  1319.  
  1320. // BEGIN flockIMediaWebService interface
  1321.  
  1322. youtubeService.prototype.migrateAccount =
  1323. function youtubeService_migrateAccount(aId, aUsername) {
  1324.   this.init();
  1325.   this.addAccountById(aId, false, null);
  1326. }
  1327.  
  1328. youtubeService.prototype.decorateForMedia =
  1329. function youtubeService_decorateForMedia(aDocument)
  1330. {
  1331.   DEBUG("{flockIMediaWebService}.decorateForMedia(aDocument)");
  1332.   aDocument.QueryInterface(Components.interfaces.nsIDOMHTMLDocument);
  1333.   var results = Components.classes["@mozilla.org/hash-property-bag;1"]
  1334.                           .createInstance(Components.interfaces.nsIWritablePropertyBag2);
  1335.   if (this.webDetective.detect("youtube", "media", aDocument, results)) {
  1336.     var mediaArr = [];
  1337.  
  1338.     // media item for user videos
  1339.     var userid = results.getPropertyAsAString("userid");
  1340.     var media = {
  1341.       name: userid,
  1342.       query: 'user:' + userid + "|username:" + userid,
  1343.       label: userid + "'s Videos", // FIXME: breaks internationalization
  1344.       favicon: this.icon,
  1345.       service: this.shortName
  1346.     }
  1347.     mediaArr.push(media);
  1348.  
  1349.     // media item for user favorites
  1350.     var media = {
  1351.       name: userid,
  1352.       query: 'favorites:' + userid,
  1353.       label: userid + "'s Favorites", // FIXME: breaks internationalization
  1354.       favicon: this.icon,
  1355.       service: this.shortName
  1356.     }
  1357.     mediaArr.push(media);
  1358.  
  1359.     if (!aDocument._flock_decorations) {
  1360.       aDocument._flock_decorations = {};
  1361.     }
  1362.     aDocument._flock_decorations.mediaArr = mediaArr;
  1363.     this.obs.notifyObservers(aDocument, 'media', 'media:update');
  1364.   }
  1365. }
  1366.  
  1367. youtubeService.prototype.handlesMediaStream =
  1368. function youtubeService_handlesMediaStream() 
  1369. {
  1370.   return true;
  1371. }
  1372.  
  1373. youtubeService.prototype.checkIsStreamUrl =
  1374. function youtubeService_checkIsStreamUrl(aUrl)
  1375. {
  1376.   if (this.webDetective.detectNoDOM("youtube", "isStreamUrl", "", aUrl, null)) {
  1377.     this._logger.debug("Checking if url is youtube stream: YES: " + aUrl);
  1378.     return true;
  1379.   }
  1380.   this._logger.debug("Checking if url is youtube stream: NO: " + aUrl);
  1381.   return false;
  1382. }
  1383.  
  1384. youtubeService.prototype.getVideoIDFromUrl = 
  1385. function youTubeService_getVideoIDFromUrl(aUrl)
  1386. {
  1387.   var videoId = null;
  1388.   //http://www.youtube.com/v/lp_daXRkOH0
  1389.   //http://www.youtube.com/watch/v/YP2rgi978tw
  1390.   //http://www.youtube.com/watch?v=BjfbS_Kj-J0
  1391.   // /player2.swf?video_id=xPxDw7ajfGE&....
  1392.   var detectResults = Cc["@mozilla.org/hash-property-bag;1"]
  1393.                       .createInstance(Ci.nsIWritablePropertyBag2);
  1394.   if (this.webDetective.detectNoDOM("youtube", "videoId", "", aUrl, detectResults)) {
  1395.     videoId = detectResults.getPropertyAsAString("videoId");
  1396.   }
  1397.   return videoId;
  1398. }
  1399.  
  1400. youtubeService.prototype.getMediaQueryFromURL =
  1401. function youTubeService_getMediaQueryFromURL(aUrl, aListener)
  1402. {
  1403.   var videoId = this.getVideoIDFromUrl(aUrl);
  1404.   if (videoId) {
  1405.     var myListener = {
  1406.       onResult: function (aXML) {
  1407.         var userID = aXML.getElementsByTagName('author')[0].firstChild.nodeValue;
  1408.         var results = Components.classes["@mozilla.org/hash-property-bag;1"]
  1409.                                 .createInstance(Components.interfaces.nsIWritablePropertyBag2);
  1410.         results.setPropertyAsAString("query", "user:" + userID + "|username:" + userID);
  1411.         // Note: The "title" property is currently not used by the media bar.
  1412.         results.setPropertyAsAString("title", userID);
  1413.         aListener.onSuccess(results, "query");
  1414.       },
  1415.       onError: function (aError) {
  1416.        aListener.onError(null, aError, null);
  1417.       }
  1418.     }
  1419.     var params = {};
  1420.     params.video_id = videoId;
  1421.     this.call(myListener, "youtube.videos.get_details", params);
  1422.   } else {
  1423.     aListener.onError(null, "Unable to get user.", null);
  1424.   }
  1425. }
  1426. // END flockIMediaWebService interface
  1427.  
  1428.  
  1429. // Checks if the TEXTAREA is drag and droppable
  1430. youtubeService.prototype._isDnDableTextarea =
  1431. function youtubeService__isDnDableTextarea(aDocument, aXPath, aTextarea)
  1432. {
  1433.   if (aDocument && aXPath && aTextarea) {
  1434.     var xpath = this.webDetective.getString("youtube", aXPath, "");
  1435.     var results = aDocument.evaluate(xpath, aDocument, null,
  1436.                                      Ci.nsIDOMXPathResult.ANY_TYPE, null);
  1437.     if (results && results.iterateNext() == aTextarea) {
  1438.       return true;
  1439.     }
  1440.   }
  1441.   return false;
  1442. }
  1443.  
  1444.  
  1445. // BEGIN flockIRichContentDropHandler
  1446. youtubeService.prototype.handleDrop =
  1447. function youtubeService_handleDrop(aFlavours, aTextarea)
  1448. {
  1449.   this._logger.info(".handleDrop()");
  1450.  
  1451.   var dropCallback = function youtube_dropCallback(aFlav) {
  1452.     var data = {}, len = {};
  1453.     aFlavours.getTransferData(aFlav, data, len);
  1454.     var caretPos = aTextarea.selectionEnd;
  1455.     var currentValue = aTextarea.value;
  1456.     // Add a trailing space so that we don't mangle the url
  1457.     var nextChar = currentValue.charAt(caretPos);
  1458.     var trailingSpace = ((nextChar == "") ||
  1459.                          (nextChar == " ") || 
  1460.                          (nextChar == "\n"))
  1461.                       ? ""
  1462.                       : " ";
  1463.     // Only add a breadcrumb if the insertion point is at the end of
  1464.     // the text so that we don't duplicate breadcrumbs
  1465.     var breadcrumb = (aTextarea.value.length == aTextarea.selectionEnd)
  1466.                    ? Cc[FLOCK_RDDS_CONTRACTID]
  1467.                        .getService(Ci.flockIRichDNDService)
  1468.                        .getBreadcrumb("plain")
  1469.                    : "";
  1470.  
  1471.     aTextarea.value = currentValue.substring(0, caretPos)
  1472.                     + data.value.QueryInterface(Ci.nsISupportsString)
  1473.                           .data.replace(/: /, ":\n")
  1474.                     + trailingSpace
  1475.                     + currentValue.substring(caretPos)
  1476.                     + breadcrumb;
  1477.   };
  1478.  
  1479.   return this._handleTextareaDrop(CATEGORY_ENTRY_NAME, this.ytService.domains,
  1480.                                   aTextarea, dropCallback);
  1481. }
  1482. // END flockIRichContentDropHandler
  1483.  
  1484. youtubeService.prototype.maxStatusLength = 0;
  1485.  
  1486. // ========== END youtubeService class ==========
  1487.  
  1488.  
  1489.  
  1490. // ================================================
  1491. // ========== BEGIN youtubeAccount class ==========
  1492. // ================================================
  1493.  
  1494. function youtubeAccount()
  1495. {
  1496.   this.acUtils = Components.classes["@flock.com/account-utils;1"]
  1497.                            .getService(Components.interfaces.flockIAccountUtils);
  1498.   this.service = Components.classes[YOUTUBE_CONTRACTID]
  1499.                            .getService(Components.interfaces.flockIWebService)
  1500.                            .QueryInterface(Components.interfaces.flockISocialWebService);
  1501.   this._coop = Components.classes["@flock.com/singleton;1"]
  1502.                          .getService(Components.interfaces.flockISingleton)
  1503.                          .getSingleton("chrome://flock/content/common/load-faves-coop.js")
  1504.                          .wrappedJSObject;
  1505.   this.webDetective = Cc["@flock.com/web-detective;1"]
  1506.                       .getService(Ci.flockIWebDetective);
  1507.   this._ctk = {
  1508.     interfaces: [
  1509.       "nsISupports",
  1510.       "flockIWebServiceAccount",
  1511.       "flockIMediaWebServiceAccount",
  1512.       "flockISocialWebServiceAccount",
  1513.       "flockIYoutubeAccount"
  1514.     ]
  1515.   };
  1516.   getCompTK().addAllInterfaces(this);
  1517.  
  1518.   this._logger = Cc["@flock.com/logger;1"].createInstance(Ci.flockILogger);
  1519.   this._logger.init("youtubeAccount");
  1520. }
  1521.  
  1522.  
  1523. // BEGIN flockIWebServiceAccount interface
  1524. youtubeAccount.prototype.urn = "";
  1525. youtubeAccount.prototype.username = "";
  1526. youtubeAccount.prototype.status = "";
  1527.  
  1528. youtubeAccount.prototype.activate =
  1529. function youtubeAccount_activate(aListener)
  1530. {
  1531.   DEBUG("{flockIWebServiceAccount}.activate()");
  1532.   var acctCoopObj = this._coop.get(this.urn);
  1533.   acctCoopObj.isPollable = true;
  1534.   if (aListener) {
  1535.     aListener.onSuccess(this, "accountAuthorized");
  1536.   }
  1537. }
  1538.  
  1539. youtubeAccount.prototype.login =
  1540. function youtubeAccount_login(aListener)
  1541. {
  1542.   DEBUG("{flockIWebServiceAccount}.login()");
  1543.   this.acUtils.ensureOnlyAuthenticatedAccount(this.urn);
  1544.   // force refresh on login
  1545.   var pollerSvc = Cc["@flock.com/poller-service;1"]
  1546.                   .getService(Ci.flockIPollerService);
  1547.   pollerSvc.forceRefresh(this.urn);
  1548.   aListener.onSuccess();
  1549. }
  1550. // END flockIWebServiceAccount interface
  1551.  
  1552.  
  1553. // BEGIN flockISocialWebServiceAccount interface
  1554. youtubeAccount.prototype.hasFriendActions = true;
  1555. youtubeAccount.prototype.isStatusSupported = false;
  1556. youtubeAccount.prototype.isStatusEditable  = false;
  1557. youtubeAccount.prototype.isPostLinkSupported = false;
  1558. youtubeAccount.prototype.isMyMediaFavoritesSupported = true;
  1559.  
  1560. youtubeAccount.prototype.setStatus =
  1561. function youtubeAccount_setStatus(aStatusMessage, aListener)
  1562. {
  1563.   this._logger.info("{flockISocialWebServiceAccount}.setStatus('"+aStatusMessage+"',"+
  1564.                                                               "'"+aListener+"')");
  1565. }
  1566.  
  1567. youtubeAccount.prototype.getEditableStatus =
  1568. function youtubeAccount_getEditableStatus()
  1569. {
  1570.   this._logger.info("{flockISocialWebServiceAccount}.getEditableStatus()");
  1571.   return "";
  1572. }
  1573.  
  1574. youtubeAccount.prototype.formatStatusForDisplay =
  1575. function youtubeAccount_formatStatusForDisplay(aStatusMessage)
  1576. {
  1577.   return "";
  1578. }
  1579.  
  1580. youtubeAccount.prototype.getMeNotifications =
  1581. function youtubeAccount_getMeNotifications()
  1582. {
  1583.   this._logger.info(".getMeNotifications()");
  1584.  
  1585.   var sbs = Cc["@mozilla.org/intl/stringbundle;1"]
  1586.             .getService(Ci.nsIStringBundleService);
  1587.   var bundle = sbs.createBundle(YOUTUBE_STRING_BUNDLE);
  1588.  
  1589.   var noties = [];
  1590.   var inst = this;
  1591.   function _addNotie(aType, aCount) {
  1592.     var stringName = "flock.youtube.noties."
  1593.                    + aType + "."
  1594.                    + ((parseInt(aCount) <= 0) ? "none" : "some");
  1595.     inst._logger.info("aType " + aType + ' aCount ' + aCount + ' name ' + stringName);
  1596.     noties.push({
  1597.       class: aType,
  1598.       tooltip: bundle.GetStringFromName(stringName),
  1599.       metricsName: aType,
  1600.       count: aCount,
  1601.       URL: inst.webDetective.getString("youtube", aType + "_URL", "")
  1602.     });
  1603.   }
  1604.   var c_acct = this._coop.get(this.urn);
  1605.   _addNotie("meMessages", c_acct.accountMessages);
  1606.   return JSON.toString(noties);
  1607. }
  1608.  
  1609. youtubeAccount.prototype.markAllMeNotificationsSeen =
  1610. function youtubeAccount_markAllMeNotificationsSeen(aType) {
  1611.   this._logger.debug(".markAllMeNotificationsSeen('" + aType + "')");
  1612.   var c_acct = this._coop.get(this.urn);
  1613.   switch (aType) {
  1614.     case "meMessages":
  1615.       c_acct.accountMessages = 0;
  1616.       break;
  1617.     default:
  1618.       break;
  1619.   }
  1620. }
  1621.  
  1622. youtubeAccount.prototype.getFriendActions =
  1623. function youtubeAccount_getFriendActions(aFriendURN)
  1624. {
  1625.   this._logger.info(".getFriendActions('" + aFriendURN + "')");
  1626.  
  1627.   var actionNames = ["friendMessage",
  1628.                      "friendViewProfile",
  1629.                      "friendMediaFave",
  1630.                      "friendShareFlock"];
  1631.  
  1632.   var sbs = Cc["@mozilla.org/intl/stringbundle;1"]
  1633.             .getService(Ci.nsIStringBundleService);
  1634.   var bundle = sbs.createBundle(YOUTUBE_STRING_BUNDLE);
  1635.  
  1636.   var actions = [];
  1637.   var c_friend = this._coop.get(aFriendURN);
  1638.   if (c_friend) {
  1639.     var c_acct = this._coop.get(this.urn);
  1640.     for each (var i in actionNames) {
  1641.       actions.push({
  1642.         label: bundle.GetStringFromName("flock.youtube.actions." + i),
  1643.         class: i,
  1644.         spec: this.webDetective.getString("youtube", i, "")
  1645.                   .replace("%accountid%", c_acct.accountId)
  1646.                   .replace("%friendid%", c_friend.accountId)
  1647.       });
  1648.     }
  1649.   }
  1650.   return JSON.toString(actions);
  1651. }
  1652.  
  1653. youtubeAccount.prototype.getSharingAction =
  1654. function youtubeAccount_getSharingAction(aFriendURN, aTransferable)
  1655. {
  1656.   this._logger.info(".getSharingAction('" + aFriendURN + "')");
  1657.  
  1658.   var sharingAction = "";
  1659.   var c_friend = this._coop.get(aFriendURN);
  1660.   if (c_friend) {
  1661.     var flavors = ["text/x-flock-media",
  1662.                    "text/x-moz-url",
  1663.                    "text/unicode",
  1664.                    "text/html"];
  1665.  
  1666.     var message = Cc[FLOCK_RDDS_CONTRACTID]
  1667.                   .getService(Ci.flockIRichDNDService)
  1668.                   .getMessageFromTransferable(aTransferable,
  1669.                                               flavors.length,
  1670.                                               flavors);
  1671.     if (!message.body) {
  1672.       return sharingAction;
  1673.     } else {
  1674.       var videoId = this.service.getVideoIDFromUrl(message.body);
  1675.       if (videoId) {
  1676.         sharingAction = this.webDetective.getString("youtube",
  1677.                                                     "shareAction_sharevideo",
  1678.                                                     "");
  1679.       } else {
  1680.         sharingAction = this.webDetective.getString("youtube",
  1681.                                                     "shareAction_privatemessage",
  1682.                                                     "");
  1683.       }
  1684.     }
  1685.   }
  1686.   this._logger.info(sharingAction);
  1687.   return sharingAction;
  1688. }
  1689.  
  1690. youtubeAccount.prototype.getProfileURLForFriend =
  1691. function youtubeAccount_getProfileURLForFriend(aFriendURN)
  1692. {
  1693.   this._logger.info(".getProfileURLForFriend('" + aFriendURN + "')");
  1694.  
  1695.   var url = "";
  1696.   var c_friend = this._coop.get(aFriendURN);
  1697.   if (c_friend) {
  1698.     url = this.webDetective.getString("youtube", "friendprofile", "")
  1699.                            .replace("%accountid%", c_friend.accountId);
  1700.   }
  1701.  
  1702.   return url;
  1703. }
  1704.  
  1705. youtubeAccount.prototype.getPostLinkAction =
  1706. function youtubeAccount_getPostLinkAction(aTransferable)
  1707. {
  1708.   return "";
  1709. }
  1710. // END flockISocialWebServiceAccount interface
  1711.  
  1712. // BEGIN flockIYoutubeAccount interface
  1713. youtubeAccount.prototype.shareFlock =
  1714. function youtubeAccount_shareFlock(aFriendURN) 
  1715. {
  1716.   this._logger.info(".shareFlock('" + aFriendURN + "')");
  1717.   
  1718.   var sbs = Cc["@mozilla.org/intl/stringbundle;1"]
  1719.               .getService(Ci.nsIStringBundleService);
  1720.   var bundle = sbs.createBundle(YOUTUBE_STRING_BUNDLE);
  1721.   var body = bundle.GetStringFromName("flock.youtube.friendShareFlock.message");
  1722.   var subj = bundle.GetStringFromName("flock.youtube.friendShareFlock.subject");
  1723.   this._composeMessage(aFriendURN, subj, body, false);
  1724. }
  1725.  
  1726. youtubeAccount.prototype.youtubePrivateMessage =
  1727. function YoutubeAccount_youtubePrivateMessage(aFriendURN, aTransferable)
  1728. {
  1729.   this._logger.info(".youtubePrivateMessage('" + aFriendURN + "')");
  1730.  
  1731.   var flavors = ["text/x-flock-media",
  1732.                  "text/x-moz-url",
  1733.                  "text/unicode",
  1734.                  "text/html"];
  1735.  
  1736.   var message = Cc[FLOCK_RDDS_CONTRACTID]
  1737.                 .getService(Ci.flockIRichDNDService)
  1738.                 .getMessageFromTransferable(aTransferable,
  1739.                                             flavors.length,
  1740.                                             flavors);
  1741.   if (message.body) {
  1742.     this._composeMessage(aFriendURN, message.subject, message.body, true);
  1743.   }
  1744. }
  1745.  
  1746. youtubeAccount.prototype.youtubeShareVideo =
  1747. function youtubeAccount_youtubeShareVideo(aFriendURN, aTransferable)
  1748. {
  1749.   this._logger.info(".youtubeShareVideo('" + aFriendURN + "')");
  1750.  
  1751.   var flavors = ["text/x-flock-media",
  1752.                  "text/x-moz-url",
  1753.                  "text/unicode",
  1754.                  "text/html"];
  1755.  
  1756.   var message = Cc[FLOCK_RDDS_CONTRACTID]
  1757.                 .getService(Ci.flockIRichDNDService)
  1758.                 .getMessageFromTransferable(aTransferable,
  1759.                                             flavors.length,
  1760.                                             flavors);
  1761.   if (message.body) {
  1762.     var inst = this;
  1763.     var share_url = inst.webDetective.getString("youtube",
  1764.                                                 "shareIframeURL", "");
  1765.     var obs = Cc["@mozilla.org/observer-service;1"]
  1766.                 .getService(Ci.nsIObserverService);
  1767.     var videoId = this.service.getVideoIDFromUrl(message.body);
  1768.     var url = this.webDetective.getString("youtube", "youtubeShare_URL", "")
  1769.                   .replace("%videoid%", videoId);
  1770.     var wm = Cc["@mozilla.org/appshell/window-mediator;1"]
  1771.                .getService(Ci.nsIWindowMediator);
  1772.     var win = wm.getMostRecentWindow("navigator:browser");
  1773.     var dimen = inst.webDetective.getString("youtube",
  1774.                                             "shareAction_sharevideo_features",
  1775.                                             "");
  1776.     win.open(url, "Share", dimen);
  1777.     win = wm.getMostRecentWindow("navigator:browser");
  1778.     flockDocumentReadyObserver = {
  1779.       observe: function openShareVideo_FormFill (aSubject, aTopic, aData) {
  1780.         if (aData == share_url) {
  1781.           obs.removeObserver(this, "FlockDocumentReady");
  1782.           var contentWindow = win.gBrowser.docShell
  1783.                                  .QueryInterface(Ci.nsIInterfaceRequestor)
  1784.                                  .getInterface(Ci.nsIDOMWindow);
  1785.  
  1786.           function insertContent(aDoc, aXpathquery, aAction, aMessage) {
  1787.             var formItems = aDoc.evaluate(aXpathquery, aDoc, null,
  1788.                                           Ci.nsIDOMXPathResult.ANY_TYPE, null);
  1789.             if (formItems) {
  1790.               var formItem = formItems.iterateNext();
  1791.               if (!formItem) {
  1792.                 return;
  1793.               }
  1794.               switch (aAction) {
  1795.                 case "click":
  1796.                   formItem.click();
  1797.                   break;
  1798.  
  1799.                 case "username":
  1800.                   if (formItem.hasAttribute("value")) {
  1801.                     formItem.setAttribute("value", aMessage);
  1802.                   }
  1803.                   break;
  1804.  
  1805.                 case "message":
  1806.                   var textNode = doc.createTextNode(aMessage);
  1807.                   formItem.appendChild(textNode);
  1808.                   break;
  1809.               
  1810.                 default:
  1811.                   inst._logger.debug("no action associated with " + aAction);
  1812.               }
  1813.             }
  1814.           }
  1815.           var doc = contentWindow.document;
  1816.           // Insert Flock bread crumb
  1817.           var breadcrumb = Cc[FLOCK_RDDS_CONTRACTID]
  1818.                              .getService(Ci.flockIRichDNDService)
  1819.                              .getBreadcrumb("plain");
  1820.           if (breadcrumb) {
  1821.             var webDicName = "youtubeshareVideo_message";
  1822.             var xpathquery = inst.webDetective.getString("youtube",
  1823.                                                          webDicName, "");
  1824.             insertContent(doc, xpathquery, "message", breadcrumb);
  1825.           }
  1826.  
  1827.           // Insert friend trying to save to into iframe
  1828.           webDicName = "youtubeshareVideo_IframeXPath";
  1829.           xpathquery = inst.webDetective.getString("youtube",
  1830.                                                    webDicName, "");
  1831.           var formItems = doc.evaluate(xpathquery, doc, null,
  1832.                                        Ci.nsIDOMXPathResult.ANY_TYPE, null);
  1833.           if (formItems) {
  1834.             var iframe = formItems.iterateNext();
  1835.             if (iframe) {
  1836.               var c_friend = inst._coop.get(aFriendURN);
  1837.               webDicName = "youtubeshareVideo_friendCheckXPath";
  1838.               xpathquery = inst.webDetective.getString("youtube", webDicName, "")
  1839.                                             .replace("%friendname%", c_friend.name);
  1840.               insertContent(iframe.contentDocument, xpathquery, "click");
  1841.             }
  1842.           }
  1843.         }
  1844.       }
  1845.     };
  1846.     obs.addObserver(flockDocumentReadyObserver, 'FlockDocumentReady', false);
  1847.   }
  1848. }
  1849.  
  1850. youtubeAccount.prototype._composeMessage =
  1851. function youtubeAccount__composeMessage(aFriendURN, aSubject, aBody, addBreadCrumb)
  1852. {
  1853.   var body = aBody;
  1854.   var subject = aSubject;
  1855.   var c_friend = this._coop.get(aFriendURN);
  1856.   var url = this.webDetective.getString("youtube", "youtubeMessage_URL", "")
  1857.                 .replace("%friendid%", c_friend.accountId);
  1858.   var wm = Cc["@mozilla.org/appshell/window-mediator;1"]
  1859.              .getService(Ci.nsIWindowMediator);
  1860.   var win = wm.getMostRecentWindow("navigator:browser");
  1861.   if (win) {
  1862.    var browser = win.getBrowser();
  1863.    var newTab = browser.loadOneTab(url, null, null, null, false, false);
  1864.    var obs = Cc["@mozilla.org/observer-service;1"]
  1865.              .getService(Ci.nsIObserverService);
  1866.    var inst = this;
  1867.    var observer = {
  1868.      observe: function openSendMessageTabForFill_observer(aContent,
  1869.                                                           aTopic,
  1870.                                                           aContextUrl)
  1871.      {
  1872.        var contentWindow = newTab.linkedBrowser.docShell
  1873.                                  .QueryInterface(Ci.nsIInterfaceRequestor)
  1874.                                  .getInterface(Ci.nsIDOMWindow);
  1875.        function insertContent(aWebDicString, aMessage) {
  1876.          var xpathquery = inst.webDetective.getString("youtube", aWebDicString, "");
  1877.          var doc = contentWindow.document;
  1878.          var formItems = doc.evaluate(xpathquery, doc, null,
  1879.                                       Ci.nsIDOMXPathResult.ANY_TYPE, null);
  1880.          if (formItems) {
  1881.            var formItem = formItems.iterateNext();
  1882.            if (formItem.hasAttribute("value")) {
  1883.              formItem.setAttribute("value", aMessage);
  1884.            } else {
  1885.              var textNode = doc.createTextNode(aMessage);
  1886.              formItem.appendChild(textNode);
  1887.              inst._logger.info("aMessage " + aMessage);
  1888.            }
  1889.          }
  1890.        }
  1891.        if (contentWindow == aContent) {
  1892.          obs.removeObserver(this, "EndDocumentLoad");
  1893.          insertContent("youtubemessage_subjectXPath", subject);
  1894.          if (addBreadCrumb) {
  1895.            // Add breadcrumb to message body
  1896.             var breadcrumb = Cc[FLOCK_RDDS_CONTRACTID]
  1897.                                .getService(Ci.flockIRichDNDService)
  1898.                                .getBreadcrumb("plain");
  1899.            if (breadcrumb) {
  1900.              body += breadcrumb;
  1901.            }
  1902.         }
  1903.          insertContent("youtubemessage_bodyXPath", body);
  1904.        }
  1905.      }
  1906.    };
  1907.    obs.addObserver(observer, "EndDocumentLoad", false);
  1908.   }
  1909. }
  1910. // END flockIYoutubeAccount interface
  1911.  
  1912. // ========== END youtubeAccount class ==========
  1913.  
  1914.  
  1915.  
  1916. // ==============================================
  1917. // ========== BEGIN XPCOM registration ==========
  1918. // ==============================================
  1919.  
  1920. function createModule(aParams) {
  1921.   return {
  1922.     registerSelf: function (aCompMgr, aFileSpec, aLocation, aType) {
  1923.       aCompMgr.QueryInterface(Ci.nsIComponentRegistrar);
  1924.       aCompMgr.registerFactoryLocation( aParams.CID, aParams.componentName,
  1925.                                         aParams.contractID, aFileSpec,
  1926.                                         aLocation, aType );
  1927.       var catMgr = Cc["@mozilla.org/categorymanager;1"]
  1928.         .getService(Ci.nsICategoryManager);
  1929.       if (!aParams.categories) { aParams.categories = []; }
  1930.       for (var i = 0; i < aParams.categories.length; i++) {
  1931.         var cat = aParams.categories[i];
  1932.         catMgr.addCategoryEntry( cat.category, cat.entry,
  1933.                                  cat.value, true, true );
  1934.       }
  1935.     },
  1936.     getClassObject: function (aCompMgr, aCID, aIID) {
  1937.       if (!aCID.equals(aParams.CID)) { throw Cr.NS_ERROR_NO_INTERFACE; }
  1938.       if (!aIID.equals(Ci.nsIFactory)) { throw Cr.NS_ERROR_NOT_IMPLEMENTED; }
  1939.       return { // Factory
  1940.         createInstance: function (aOuter, aIID) {
  1941.           if (aOuter != null) { throw Cr.NS_ERROR_NO_AGGREGATION; }
  1942.           var comp = new aParams.componentClass();
  1943.           if (aParams.implementationFunc) { aParams.implementationFunc(comp); }
  1944.           return comp.QueryInterface(aIID);
  1945.         }
  1946.       };
  1947.     },
  1948.     canUnload: function (aCompMgr) { return true; }
  1949.   };
  1950. }
  1951.  
  1952. // NS Module entrypoint
  1953. function NSGetModule(aCompMgr, aFileSpec) {
  1954.   return createModule({
  1955.     componentClass: youtubeService,
  1956.     CID: YOUTUBE_CID,
  1957.     contractID: YOUTUBE_CONTRACTID,
  1958.     componentName: CATEGORY_COMPONENT_NAME,
  1959.     implementationFunc: function (aComp) { getCompTK().addAllInterfaces(aComp); },
  1960.     categories: [
  1961.       { category: "wsm-startup", entry: CATEGORY_COMPONENT_NAME, value: YOUTUBE_CONTRACTID },
  1962.       { category: "flockWebService", entry: CATEGORY_ENTRY_NAME, value: YOUTUBE_CONTRACTID },
  1963.       { category: "flockMediaProvider", entry: CATEGORY_ENTRY_NAME, value: YOUTUBE_CONTRACTID },
  1964.       { category: "flockRichContentHandler", entry: CATEGORY_ENTRY_NAME, value: YOUTUBE_CONTRACTID }
  1965.     ]
  1966.   });
  1967. }
  1968.  
  1969. // ========== END XPCOM registration ==========
  1970.  
  1971.  
  1972.  
  1973. // HELPER STUFF
  1974.  
  1975. function loadSubScript(spec)
  1976. {
  1977.   var loader = Components.classes["@mozilla.org/moz/jssubscript-loader;1"]
  1978.                          .getService(Components.interfaces.mozIJSSubScriptLoader);
  1979.   var context = {};
  1980.   loader.loadSubScript(spec, context);
  1981.   return context;
  1982. }
  1983.  
  1984. function loadLibraryFromSpec(aSpec)
  1985. {
  1986.   var loader = Components.classes["@mozilla.org/moz/jssubscript-loader;1"]
  1987.                          .getService(Components.interfaces.mozIJSSubScriptLoader);
  1988.   loader.loadSubScript(aSpec);
  1989. }
  1990.